Research
Security News
Quasar RAT Disguised as an npm Package for Detecting Vulnerabilities in Ethereum Smart Contracts
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
The bn.js package is a library that provides support for arbitrary-precision arithmetic operations on big numbers in JavaScript. It is commonly used in cryptography, financial calculations, and anywhere precise arithmetic with large integers is required.
Big Number Arithmetic
Performing basic arithmetic operations such as addition, subtraction, multiplication, division, and modulo on big numbers.
const BN = require('bn.js');
let a = new BN('123456789');
let b = new BN('987654321');
let sum = a.add(b); // Addition
let diff = a.sub(b); // Subtraction
let product = a.mul(b); // Multiplication
let quotient = a.div(b); // Division
let remainder = a.mod(b); // Modulo
Comparison Operations
Comparing big numbers to determine if they are equal, less than, or greater than each other.
const BN = require('bn.js');
let a = new BN('12345');
let b = new BN('12345');
let c = new BN('54321');
a.eq(b); // true, a equals b
a.lt(c); // true, a is less than c
a.gt(c); // false, a is not greater than c
Bitwise Operations
Performing bitwise operations such as AND, OR, XOR, and NOT on big numbers.
const BN = require('bn.js');
let a = new BN('1011', 2);
let b = new BN('1101', 2);
let and = a.and(b); // AND operation
let or = a.or(b); // OR operation
let xor = a.xor(b); // XOR operation
let not = a.not(); // NOT operation
Reduction Contexts
Using reduction contexts to perform modular arithmetic efficiently, particularly useful in modular exponentiation and cryptographic operations.
const BN = require('bn.js');
let p = new BN('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 16);
let a = new BN('7fffffffffffffffffffffff7ffffe17ff', 16);
let red = BN.red(p);
let b = a.toRed(red); // Convert to Montgomery representation
let c = b.redSqr().redMul(b); // Perform operations in reduction context
let d = c.fromRed(); // Convert out of Montgomery representation
big.js is a small, fast JavaScript library for arbitrary-precision decimal arithmetic. It focuses on decimal numbers and provides a simpler API but does not support bitwise operations like bn.js.
bignumber.js is another arbitrary-precision arithmetic library for JavaScript and Node.js. It supports decimal and non-decimal arithmetic and has a more extensive API than bn.js, but it might be slower for some operations due to its focus on decimal precision.
decimal.js is a library for arbitrary-precision decimal arithmetic. It is similar to bignumber.js in its focus on decimal numbers and provides a comprehensive set of features for decimal arithmetic, but it does not provide the same level of support for non-decimal and bitwise operations as bn.js.
BigNum in pure javascript
npm install --save bn.js
const BN = require('bn.js');
var a = new BN('dead', 16);
var b = new BN('101010', 2);
var res = a.add(b);
console.log(res.toString(10)); // 57047
Note: decimals are not supported in this library.
There are several prefixes to instructions that affect the way the work. Here is the list of them in the order of appearance in the function name:
i
- perform operation in-place, storing the result in the host object (on
which the method was invoked). Might be used to avoid number allocation costsu
- unsigned, ignore the sign of operands when performing operation, or
always return positive value. Second case applies to reduction operations
like mod()
. In such cases if the result will be negative - modulo will be
added to the result to make it positiveThe only available postfix at the moment is:
n
- which means that the argument of the function must be a plain JavaScript
Number. Decimals are not supported.a.iadd(b)
- perform addition on a
and b
, storing the result in a
a.umod(b)
- reduce a
modulo b
, returning positive valuea.iushln(13)
- shift bits of a
left by 13Prefixes/postfixes are put in parens at the of the line. endian
- could be
either le
(little-endian) or be
(big-endian).
a.clone()
- clone numbera.toString(base, length)
- convert to base-string and pad with zeroesa.toNumber()
- convert to Javascript Number (limited to 53 bits)a.toJSON()
- convert to JSON compatible hex string (alias of toString(16)
)a.toArray(endian, length)
- convert to byte Array
, and optionally zero
pad to length, throwing if already exceedinga.toArrayLike(type, endian, length)
- convert to an instance of type
,
which must behave like an Array
a.toBuffer(endian, length)
- convert to Node.js Buffer (if available). For
compatibility with browserify and similar tools, use this instead:
a.toArrayLike(Buffer, endian, length)
a.bitLength()
- get number of bits occupieda.zeroBits()
- return number of less-significant consequent zero bits
(example: 1010000
has 4 zero bits)a.byteLength()
- return number of bytes occupieda.isNeg()
- true if the number is negativea.isEven()
- no commentsa.isOdd()
- no commentsa.isZero()
- no commentsa.cmp(b)
- compare numbers and return -1
(a <
b), 0
(a ==
b), or 1
(a >
b)
depending on the comparison result (ucmp
, cmpn
)a.lt(b)
- a
less than b
(n
)a.lte(b)
- a
less than or equals b
(n
)a.gt(b)
- a
greater than b
(n
)a.gte(b)
- a
greater than or equals b
(n
)a.eq(b)
- a
equals b
(n
)a.toTwos(width)
- convert to two's complement representation, where width
is bit widtha.fromTwos(width)
- convert from two's complement representation, where width
is the bit widthBN.isBN(object)
- returns true if the supplied object
is a BN.js instancea.neg()
- negate sign (i
)a.abs()
- absolute value (i
)a.add(b)
- addition (i
, n
, in
)a.sub(b)
- subtraction (i
, n
, in
)a.mul(b)
- multiply (i
, n
, in
)a.sqr()
- square (i
)a.pow(b)
- raise a
to the power of b
a.div(b)
- divide (divn
, idivn
)a.mod(b)
- reduct (u
, n
) (but no umodn
)a.divRound(b)
- rounded divisiona.or(b)
- or (i
, u
, iu
)a.and(b)
- and (i
, u
, iu
, andln
) (NOTE: andln
is going to be replaced
with andn
in future)a.xor(b)
- xor (i
, u
, iu
)a.setn(b)
- set specified bit to 1
a.shln(b)
- shift left (i
, u
, iu
)a.shrn(b)
- shift right (i
, u
, iu
)a.testn(b)
- test if specified bit is seta.maskn(b)
- clear bits with indexes higher or equal to b
(i
)a.bincn(b)
- add 1 << b
to the numbera.notn(w)
- not (for the width specified by w
) (i
)a.gcd(b)
- GCDa.egcd(b)
- Extended GCD results ({ a: ..., b: ..., gcd: ... }
)a.invm(b)
- inverse a
modulo b
When doing lots of reductions using the same modulo, it might be beneficial to use some tricks: like Montgomery multiplication, or using special algorithm for Mersenne Prime.
To enable this tricks one should create a reduction context:
var red = BN.red(num);
where num
is just a BN instance.
Or:
var red = BN.red(primeName);
Where primeName
is either of these Mersenne Primes:
'k256'
'p224'
'p192'
'p25519'
Or:
var red = BN.mont(num);
To reduce numbers with Montgomery trick. .mont()
is generally faster than
.red(num)
, but slower than BN.red(primeName)
.
Before performing anything in reduction context - numbers should be converted to it. Usually, this means that one should:
Here is how one may convert numbers to red
:
var redA = a.toRed(red);
Where red
is a reduction context created using instructions above
Here is how to convert them back:
var a = redA.fromRed();
Most of the instructions from the very start of this readme have their counterparts in red context:
a.redAdd(b)
, a.redIAdd(b)
a.redSub(b)
, a.redISub(b)
a.redShl(num)
a.redMul(b)
, a.redIMul(b)
a.redSqr()
, a.redISqr()
a.redSqrt()
- square root modulo reduction context's primea.redInvm()
- modular inverse of the numbera.redNeg()
a.redPow(b)
- modular exponentiationThis software is licensed under the MIT License.
FAQs
Big number implementation in pure javascript
The npm package bn.js receives a total of 29,885,403 weekly downloads. As such, bn.js popularity was classified as popular.
We found that bn.js demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 4 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
Security News
Research
A supply chain attack on Rspack's npm packages injected cryptomining malware, potentially impacting thousands of developers.
Research
Security News
Socket researchers discovered a malware campaign on npm delivering the Skuld infostealer via typosquatted packages, exposing sensitive data.